package com.huisenky.smallidea.devalue;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.format.FastDateFormat;
import cn.hutool.core.util.ReflectUtil;


import java.lang.reflect.Field;
import java.util.*;


/**
 * set class Default val
 *
 */
public class DeUtil {

    private DeUtil() {
    }




    /**
     * bean 设置默认值
     */
    public static void setDefaultVal(Object target, String... ignoreProperties) {
        setDefaultVal(target, target.getClass(), null, ignoreProperties);
    }

    /**
     * 查询下 String 这种的默认值是什么
     */
    public static <T> T getDefaultVal(Class<T> clazz) {
        return getDefaultVal(clazz, null);
    }

    /**
     * 设置默认值
     *
     * @param target            目标对象
     * @param clazz             模板，依据该类中字段的名称和类型对目标对象中注入默认值
     * @param registrationClass 默认值注册类
     * @param ignoreProperties  需要忽略的参数
     */
    public static void setDefaultVal(Object target, Class<?> clazz, Class<? extends AbstractTypeValRegistration> registrationClass, String... ignoreProperties) {
        if (target == null || clazz == null) {
            return;
        }
        Field[] fields = ReflectUtil.getFields(clazz);
        AbstractTypeValRegistration registration = registrationClass == null ? new DefaultTypeValRegistration() : ReflectUtil.newInstance(registrationClass);
        for (Field field : fields) {
            String fieldName = field.getName();
            if (!Arrays.asList(ignoreProperties).contains(fieldName)) {
                Object value = ReflectUtil.getFieldValue(target, fieldName);
                if (value == null) {
                    Map<Class<?>, Object> typeVal = registration.getTypeVal();
                    if (typeVal.get(field.getType()) != null) {
                        try {
                            ReflectUtil.setFieldValue(target, fieldName, typeVal.get(field.getType()));
                        } catch (Exception e) {
                            // 忽略
                        }
                    }
                }
            }
        }
    }

    /**
     * 获取类型的默认值
     *
     * @param clazz             类型
     * @param registrationClass 默认值注册类
     * @return 默认值
     */
    @SuppressWarnings("unchecked")
    public static <T> T getDefaultVal(Class<T> clazz, Class<? extends AbstractTypeValRegistration> registrationClass) {
        if (clazz == null) {
            return null;
        }
        AbstractTypeValRegistration registration = registrationClass == null ? new DefaultTypeValRegistration() : ReflectUtil.newInstance(registrationClass);
        Map<Class<?>, Object> typeVal = registration.getTypeVal();
        Object defaultVal = typeVal.get(clazz);
        if (defaultVal.getClass().equals(clazz)) {
            return (T) typeVal.get(clazz);
        } else {
            return null;
        }
    }





    /**
     * 快速的 date to str
     */
    public static String mapStrDate(Date date,FastDateFormat parseFormat) {
        try {
            return DateUtil.format(date,parseFormat);
        }catch (Exception e){
            return null;
        }
    }

    public static String mapStrDate(Date date) {
        return mapStrDate(date,DatePattern.NORM_DATETIME_FORMAT);
    }


    /**
     * 快速的 str转date
     *
     * map date string
     * 如果str能够转换，则返回转换时间，否则返回null
     *
     * @param str         待map的string
     * @param parseFormat 转换格式，详见DatePattern
     * @return 转换后的时间
     */
    public static Date mapDateStr(String str, FastDateFormat parseFormat) {
        try {
            return DateUtil.parse(str, parseFormat);
        } catch (Exception e) {
            return null;
        }
    }

    /*
    DatePattern 定义了fastDateFormat
     */
    public static Date mapDateStr(String str) {
        return mapDateStr(str, DatePattern.NORM_DATETIME_FORMAT);
    }






}
